🔮 UNNS Many-Faces Theorem - Complete Visualization Suite

Sequence Type

Number of Terms 25

Modular Domain (m) 7

Define Custom Linear Recurrence

Seeds (comma-separated):

Coefficients (newest to oldest):

📊 Linear Recurrence Values

Current sequence:

Recurrence:

🌀 2D Geometric Spiral

Dominant root:

Convergence ratio:

🎨 Modular Domain Partition

Modulus m =

Residue distribution:

📈 Ratio Convergence

Converging to:

Current error:

🎭 3D Helical Visualization

Mouse: Rotate | Scroll: Zoom | Right-click: Pan

Showing spiral embedding in 3D space with radial growth following sequence values

💡 Pro Tips & Shortcuts

Advanced Usage:

Compare Sequences: Export multiple sequences as JSON, then compare in Python
Find Patterns: Try the same modulus across different sequences
Performance: For large terms (>50), some sequences may slow down due to exponential growth
Custom Exploration: Try negative coefficients for oscillating sequences
3D Navigation: Move mouse slowly for smooth rotation, quick moves for spin

Common Questions:

Q: Why do some bars disappear? A: Values too large cause overflow - normal for exponential sequences
Q: What's the best modulus to use? A: Try primes (5,7,11,13) for interesting patterns
Q: Can I save the visualizations? A: Right-click any canvas to save as image
Q: How accurate are the calculations? A: JavaScript uses 64-bit floats, accurate to ~15 digits

Educational Activities:

Predict the dominant root before checking
Find sequences with the same dominant root
Discover which sequences have uniform modular distribution
Create a custom sequence that converges to exactly 2
Export data and verify Binet's formula in Python

The Many-Faces Theorem

Theorem 1 (UNNS Many-Faces): Let U = (S, C, G, {μ_D}) be a UNNS system. Then:

Linear recurrence embedding: Any linear recurrence a_n = c₁a_{n-1} + ... + c_ra_{n-r} can be embedded.
Dominant-root attractor: If the characteristic polynomial has unique dominant root r_d, then lim(s_{n+1}/s_n) = r_d.
Modular domain partition: Residues mod m partition nests into m evolving domains.
Cross-domain homomorphism: Constructive mappings exist between domain encodings.
Computational completeness: With appropriate combinators, UNNS can simulate Turing machines.

Proof Sketch: Fibonacci Embedding

Construction:

UNNS System U = (S, C, G, μ_Z) where:
- S = ℤ (nests as integers)
- G = {0, 1} (seeds)
- C = {★} where ★(x,y) = x + y
- μ_Z: S → ℤ is identity

Sequence generation:
s₀ = 0, s₁ = 1
s_{n+1} = ★(s_{n-1}, s_n) = s_{n-1} + s_n

Inductive Proof:

Base: s₀ = 0 = F₀, s₁ = 1 = F₁ ✓

Inductive step: Assume μ_Z(s_k) = F_k for k ≤ n
Then: μ_Z(s_{n+1}) = μ_Z(★(s_{n-1}, s_n))
                    = μ_Z(s_{n-1} + s_n)
                    = F_{n-1} + F_n
                    = F_{n+1} ✓

Convergence: By Binet's formula,
F_n = (φⁿ - ψⁿ)/√5 where φ = (1+√5)/2

Therefore: lim(F_{n+1}/F_n) = φ (golden ratio)

Python Verification Script

import json
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

def verify_unns_convergence(sequence_data):
    """Verify UNNS convergence properties"""
    values = sequence_data['values']
    dominant = sequence_data['dominant_root']
    
    # Calculate ratios
    ratios = [values[i]/values[i-1] 
              for i in range(1, len(values)) 
              if values[i-1] != 0]
    
    # Calculate convergence errors
    errors = [abs(r - dominant) for r in ratios]
    
    # Fit exponential decay to error
    x = np.arange(len(errors))
    
    def exp_decay(x, a, b):
        return a * np.exp(-b * x)
    
    try:
        popt, _ = curve_fit(exp_decay, x[5:], errors[5:])
        print(f"Error decay rate: {popt[1]:.4f}")
    except:
        print("Could not fit exponential decay")
    
    # Visualization
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # Sequence values
    axes[0,0].semilogy(values[:50], 'b-', marker='o', markersize=3)
    axes[0,0].set_title('Sequence Values (log scale)')
    axes[0,0].set_xlabel('n')
    axes[0,0].set_ylabel('Value')
    axes[0,0].grid(True, alpha=0.3)
    
    # Ratio convergence
    axes[0,1].plot(ratios, 'g-', label='Ratios')
    axes[0,1].axhline(y=dominant, color='r', 
                       linestyle='--', label=f'Dominant root: {dominant:.6f}')
    axes[0,1].set_title('Ratio Convergence')
    axes[0,1].set_xlabel('n')
    axes[0,1].set_ylabel('s(n+1)/s(n)')
    axes[0,1].legend()
    axes[0,1].grid(True, alpha=0.3)
    
    # Error decay
    axes[1,0].semilogy(errors, 'r-', label='Actual error')
    if 'popt' in locals():
        axes[1,0].semilogy(x, exp_decay(x, *popt), 
                          'b--', label='Exponential fit')
    axes[1,0].set_title('Convergence Error')
    axes[1,0].set_xlabel('n')
    axes[1,0].set_ylabel('|ratio - dominant root|')
    axes[1,0].legend()
    axes[1,0].grid(True, alpha=0.3)
    
    # Modular partition (example with m=7)
    m = 7
    residues = [v % m for v in values[:100]]
    axes[1,1].hist(residues, bins=m, alpha=0.7, 
                   color='purple', edgecolor='black')
    axes[1,1].set_title(f'Modular Partition (mod {m})')
    axes[1,1].set_xlabel('Residue class')
    axes[1,1].set_ylabel('Frequency')
    axes[1,1].set_xticks(range(m))
    axes[1,1].grid(True, alpha=0.3)
    
    plt.suptitle(f"{sequence_data['sequence']} - UNNS Properties Verification")
    plt.tight_layout()
    plt.show()
    
    return {
        'final_ratio': ratios[-1] if ratios else 0,
        'final_error': errors[-1] if errors else 0,
        'convergence_rate': popt[1] if 'popt' in locals() else None
    }

# Usage:
# Load exported JSON data from the visualization
with open('unns_fibonacci_50.json', 'r') as f:
    data = json.load(f)
    results = verify_unns_convergence(data)
    print(f"Final convergence error: {results['final_error']:.2e}")

Key Insights

Universality: UNNS provides a unified framework for diverse mathematical sequences
Attractors: Dominant eigenvalues naturally emerge as geometric attractors
Modularity: Residue classes create finite-state subsystems within infinite sequences
Cross-domain mapping: The same sequence has multiple valid representations
Computational power: With proper combinators, UNNS achieves Turing completeness